// upload.js 修改内容
import axios from 'axios'
import { getToken } from '@/utils/auth'

class FileUploadUtil {
    constructor() {
        this.filesInfo = [];
    }

    // 重置并创建新的文件数据对象（关键修正：每次返回新对象）
    createFileData() {
        return {
            file: null,
            fileName: '',
            fileSize: 0,
            fileType: '',
            fileExtension: '',
            content: null,
            previewUrl: null,
            loading: false,
            progress: 0,
            error: '',
            reader: null,
            skuId: 99,
        }
    }

    /**
     * 处理文件上传
     * @param {File} file - 要上传的文件
     * @param {Object} options - 配置选项
     */
    handleFileUpload(file, options = {}) {
        // 关键修正：每次处理文件时创建新的fileData对象
        const fileData = this.createFileData();

        if (!file) {
            fileData.error = '未选择文件';
            this.filesInfo.push(fileData);
            return;
        }

        // 保存文件信息到当前fileData
        fileData.file = file;
        fileData.fileName = file.name;
        fileData.fileSize = file.size;
        fileData.fileType = file.type;
        fileData.skuId = 99;

        // 获取文件扩展名
        const lastDotIndex = file.name.lastIndexOf('.');
        fileData.fileExtension = lastDotIndex > 0
            ? file.name.substring(lastDotIndex + 1).toLowerCase()
            : '';

        // 验证文件类型（修正：传递当前fileData的file）
        if (options.acceptTypes && !this.isTypeAllowed(options.acceptTypes, fileData.file)) {
            fileData.error = `不支持的文件类型，允许的类型: ${this.formatAcceptTypes(options.acceptTypes)}`;
            this.filesInfo.push(fileData);
            return;
        }

        // 验证文件大小
        if (options.maxSize && file.size > options.maxSize) {
            fileData.error = `文件过大，最大支持 ${this.formatFileSize(options.maxSize)}`;
            this.filesInfo.push(fileData);
            return;
        }

        // 处理文件预览和读取（修正：传递当前fileData）
        this.processFile(fileData);
        this.filesInfo.push(fileData);
    }

    /**
     * 检查文件类型是否被允许
     * @param {Array} acceptTypes - 允许的文件类型数组
     * @param {File} file - 要检查的文件
     * @returns {boolean} 是否允许
     */
    isTypeAllowed(acceptTypes, file) { // 修正：移除默认参数，强制传入file
        if (!file) return false;

        if (acceptTypes.includes('*/*')) return true;

        for (const type of acceptTypes) {
            if (type.endsWith('*')) {
                const baseType = type.split('/')[0];
                if (file.type.startsWith(baseType)) {
                    return true;
                }
            } else if (file.type === type) {
                return true;
            } else if (type.startsWith('.') && this.getFileExtension(file) === type.substring(1)) {
                return true;
            }
        }

        return false;
    }

    getFileExtension(file) {
        const lastDotIndex = file.name.lastIndexOf('.');
        return lastDotIndex > 0
            ? file.name.substring(lastDotIndex + 1).toLowerCase()
            : '';
    }

    formatAcceptTypes(acceptTypes) {
        return acceptTypes.map(type => {
            if (type === '*/*') return '所有文件';
            if (type.endsWith('*')) return type.split('/')[0] + '文件';
            if (type.startsWith('.')) return type.toUpperCase() + '文件';
            return type.split('/')[1] + '文件';
        }).join('、');
    }

    /**
     * 处理文件读取和预览（修正：接收fileData参数）
     * @param {Object} fileData - 当前文件数据对象
     */
    processFile(fileData) {
        fileData.reader = new FileReader();
        fileData.reader.onabort = () => { /* 处理中断 */ };

        if (this.isImage(fileData)) {
            fileData.previewUrl = URL.createObjectURL(fileData.file);
            fileData.reader.readAsDataURL(fileData.file); // 修正：使用fileData.file
        } else if (this.isVideo(fileData)) {
            fileData.previewUrl = URL.createObjectURL(fileData.file);
            fileData.reader.readAsArrayBuffer(fileData.file);
        } else if (this.isTextFile(fileData)) {
            fileData.reader.readAsText(fileData.file);
        } else {
            fileData.reader.readAsArrayBuffer(fileData.file);
        }
    }

    // 修正：所有类型判断方法接收fileData参数
    isImage(fileData) {
        return fileData.fileType.startsWith('image/');
    }
    isVideo(fileData) {
        return fileData.fileType.startsWith('video/');
    }
    isTextFile(fileData) {
        const textExtensions = ['txt', 'csv', 'html', 'css', 'js', 'json', 'xml', 'md'];
        return fileData.fileType.startsWith('text/') || textExtensions.includes(fileData.fileExtension);
    }
    isDocument(fileData) {
        const docExtensions = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx'];
        return docExtensions.includes(fileData.fileExtension);
    }

    removeFile(index) {
        this.revokePreviewUrl(this.filesInfo[index]);
        this.filesInfo.splice(index, 1);
    }

    revokePreviewUrl(item) {
        if (item.previewUrl) {
            URL.revokeObjectURL(item.previewUrl);
            item.previewUrl = null;
        }
    }

    /**
     * 上传文件到服务器（修正：正确处理文件列表）
     * @param {string} url - 服务器上传地址
     * @param {Object} additionalData - 额外的表单数据
     * @returns {Promise} 返回上传结果的Promise
     */
    uploadToServer(url, additionalData = {}) {
        return new Promise((resolve, reject) => {
            if (this.filesInfo.length === 0) {
                reject(new Error('没有可上传的文件'));
                return;
            }

            const formData = new FormData();
            // 修正：循环添加所有文件
            this.filesInfo.forEach(item => {
                formData.append('files', item.file);
            });
            formData.append("skuId", additionalData.skuId || 99);

            Object.keys(additionalData).forEach(key => {
                formData.append(key, additionalData[key]);
            });
            //遍历输出formData中的值
            for (let [key, value] of formData.entries()) {
                console.log(key, value);
            }
            axios.post(url, formData, {
                // onUploadProgress: (e) => {
                //     if (e.lengthComputable) {
                //         const progress = (e.loaded / e.total) * 100;
                //         console.log(`文件上传进度: ${progress.toFixed(2)}%`);
                //     }
                // },
                headers: {
                    'Authorization': 'Bearer ' + getToken()
                }
            })
                .then(response => resolve(response))
                .catch(error => {
                    const errorMsg = error.response
                        ? `上传失败: 服务器返回状态码 ${error.response.status}`
                        : error.request
                            ? '上传失败: 网络错误'
                            : error.message
                                ? `上传失败: ${error.message}`
                                : '上传失败: 发生未知错误';
                    reject(new Error(errorMsg));
                });
        });
    }

    formatFileSize(bytes) {
        if (bytes === 0) return '0 Bytes';
        const k = 1024;
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
    }
}

export default FileUploadUtil;